/**
 * 
 */
package com.ls.lserp.common.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import org.apache.commons.lang3.time.DateFormatUtils;

/**
 * 日期工具类, 继承org.apache.commons.lang.time.DateUtils类
 * 
 * @author
 * @version 2014-4-15
 */
public class DateUtils extends org.apache.commons.lang3.time.DateUtils {

	private static String[] parsePatterns = { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
			"yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM", "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss",
			"yyyy.MM.dd HH:mm", "yyyy.MM" };

	/**
	 * 得到当前日期字符串 格式（yyyy-MM-dd）
	 */
	public static String getDate() {
		return getDate("yyyy-MM-dd");
	}

	/**
	 * 得到当前日期字符串 格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
	 */
	public static String getDate(String pattern) {
		return DateFormatUtils.format(new Date(), pattern);
	}

	/**
	 * 得到日期字符串 默认格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
	 */
	public static String formatDate(Date date, Object... pattern) {
		String formatDate = null;
		if (pattern != null && pattern.length > 0) {
			formatDate = DateFormatUtils.format(date, pattern[0].toString());
		} else {
			formatDate = DateFormatUtils.format(date, "yyyy-MM-dd");
		}
		return formatDate;
	}

	/**
	 * 得到日期时间字符串，转换格式（yyyy-MM-dd HH:mm:ss）
	 */
	public static String formatDateTime(Date date) {
		return formatDate(date, "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 得到当前时间字符串 格式（HH:mm:ss）
	 */
	public static String getTime() {
		return formatDate(new Date(), "HH:mm:ss");
	}

	/**
	 * 得到当前日期和时间字符串 格式（yyyy-MM-dd HH:mm:ss）
	 */
	public static String getDateTime() {
		return formatDate(new Date(), "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 得到当前年份字符串 格式（yyyy）
	 */
	public static String getYear() {
		return formatDate(new Date(), "yyyy");
	}

	/**
	 * 得到当前月份字符串 格式（MM）
	 */
	public static String getMonth() {
		return formatDate(new Date(), "MM");
	}

	/**
	 * 得到当天字符串 格式（dd）
	 */
	public static String getDay() {
		return formatDate(new Date(), "dd");
	}

	/**
	 * 得到当前星期字符串 格式（E）星期几
	 */
	public static String getWeek() {
		return formatDate(new Date(), "E");
	}

	/**
	 * 日期型字符串转化为日期 格式 { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm",
	 * "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy.MM.dd",
	 * "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm" }
	 */
	public static Date parseDate(Object str) {
		if (str == null) {
			return null;
		}
		try {
			return parseDate(str.toString(), parsePatterns);
		} catch (ParseException e) {
			return null;
		}
	}

	/**
	 * 获取过去的天数
	 * 
	 * @param date
	 * @return
	 */
	public static long pastDays(Date date) {
		long t = new Date().getTime() - date.getTime();
		return t / (24 * 60 * 60 * 1000);
	}

	/**
	 * 获取过去的小时
	 * 
	 * @param date
	 * @return
	 */
	public static long pastHour(Date date) {
		long t = new Date().getTime() - date.getTime();
		return t / (60 * 60 * 1000);
	}

	/**
	 * 获取过去的分钟
	 * 
	 * @param date
	 * @return
	 */
	public static long pastMinutes(Date date) {
		long t = new Date().getTime() - date.getTime();
		return t / (60 * 1000);
	}

	/**
	 * 转换为时间（天,时:分:秒.毫秒）
	 * 
	 * @param timeMillis
	 * @return
	 */
	public static String formatDateTime(long timeMillis) {
		long day = timeMillis / (24 * 60 * 60 * 1000);
		long hour = (timeMillis / (60 * 60 * 1000) - day * 24);
		long min = ((timeMillis / (60 * 1000)) - day * 24 * 60 - hour * 60);
		long s = (timeMillis / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
		long sss = (timeMillis - day * 24 * 60 * 60 * 1000 - hour * 60 * 60 * 1000 - min * 60 * 1000 - s * 1000);
		return (day > 0 ? day + "," : "") + hour + ":" + min + ":" + s + "." + sss;
	}

	/**
	 * 获取两个日期之间的天数
	 * 
	 * @param before
	 * @param after
	 * @return
	 */
	public static double getDistanceOfTwoDate(Date before, Date after) {
		long beforeTime = before.getTime();
		long afterTime = after.getTime();
		return (afterTime - beforeTime) / (1000 * 60 * 60 * 24);
	}

	/**
	 * 得到参数代表的日期是一周中的第几天
	 * 
	 * @param date
	 * @return
	 */
	public static int getDayOfWeek(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(Calendar.DAY_OF_WEEK);
	}

	/**
	 * 得到几天后的时间
	 * 
	 * @param d
	 * @param day
	 * @return
	 */
	public static Date getDateAfter(Date d, int day) {
		Calendar now = Calendar.getInstance();
		now.setTime(d);
		now.set(Calendar.DATE, now.get(Calendar.DATE) + day);
		return now.getTime();
	}

	/**
	 * 得到几天后的时间
	 * 
	 * @param d
	 * @param day
	 * @return
	 */
	public static String getDateAfter(Date d, int day, String parsePattern) {
		Date date = getDateAfter(d, day);
		return formatDate(date, parsePattern);
	}

	/**
	 * 判断是否为工作日
	 * 
	 * @param d
	 * @return
	 */
	public static Boolean isWorkDay(Date d) {

		return (int) getDayOfWeek(d) > 1 && (int) getDayOfWeek(d) < 7;
	}

	/**
	 * 得到几个工作日的时间
	 * 
	 * @param d
	 * @param n
	 * @return
	 */
	public static Date getDateAfterWorkDay(Date d, int n) {
		// 取绝对值
		int j = Math.abs(n);
		// 需要相加的天数
		int i = 0;
		// 判断是向前还是向后
		int front = n < 0 ? -1 : 1;
		// 循环满足n个工作日需要加的天数
		while (j > 0) {
			// 循环一次需要相加的天数加一
			i++;
			// 判断是工作日减一
			if (isWorkDay(getDateAfter(d, i * front))) {
				j--;
			}
		}
		return getDateAfter(d, i * front);
	}

	/**
	 * 得到几个工作日的时间
	 * 
	 * @param d
	 * @param n
	 * @param parsePattern
	 * @return
	 */
	public static String getDateAfterWorkDay(Date d, int n, String parsePattern) {

		return formatDate(getDateAfterWorkDay(d, n), parsePattern);
	}

	/**
	 * 根据日期取得星期几
	 * 
	 * @param d
	 * @return
	 */
	public static String getWeekFromDate(Date date) {
		String[] weeks = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
		if (week_index < 0) {
			week_index = 0;
		}
		return weeks[week_index];
	}

	public static long getDateToPull(Long number) {

		DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		String strDate = String.valueOf(number);

		if (strDate.length() == 8) {
			strDate = strDate.substring(0, 4) + "-" + strDate.substring(4, 6) + "-" + strDate.substring(6);
			format = DateFormat.getDateInstance(DateFormat.MEDIUM);
			Date date = java.sql.Date.valueOf(strDate);
			strDate = DateUtils.formatDate(DateUtils.getDateAfter(date, 7));
			number = Long.parseLong(strDate.replaceAll("-", ""));
		}

		return number;
	}

	/**
	 * @param args
	 * @throws ParseException
	 */
	public static void main(String[] args) throws ParseException {
		// System.out.println(formatDate(parseDate("2010/3/6")));
		// System.out.println(getDate("yyyy年MM月dd日 E"));
		// long time = new Date().getTime()-parseDate("2012-11-19").getTime();
		// System.out.println(time/(24*60*60*1000));
		System.out.println(getDateAfterWorkDay(new Date(), -7, "yyyy-MM-dd"));
	}
	
	/**
	 * 预计日期计算
	 * @param days 当前日
	 * @param month 当前月
	 * @param  year 当前年
	 * @param dValue 目标消耗工作日天数 （例:[dValue=7 ，消耗7天工作日]）
	 * @return Date
	 */
	public static Date getTargerDate(int year,int month,int days,int dValue) {
		// 声明日期类 Calender
		Calendar calendar=Calendar.getInstance();
		Calendar cTemp = Calendar.getInstance();
		// 设置当前订单日期
		calendar.set(year,month-1,days);
		// 算出当前是周几
		int dayTemp = calendar.get(Calendar.DAY_OF_WEEK);
		/*// 算出离下个周六差几天
		int count = (7 - dayTemp) + dValue;
		// 算出预计交付日
		cTemp.set(Calendar.DAY_OF_MONTH,days + count);*/
		
		// 初步算出预计日期，当前日期   + 目标消耗工作日天数 + 包含的周六周日天数。
		int resultDays =  days + dValue + dValue/7*2;
		// 若当前日期为星期六，则预计日期加1。
		if (dayTemp == 7) {
			resultDays += 1;
		}
		// 设置计算后日期
		cTemp.set(Calendar.DAY_OF_MONTH,resultDays);
		// 若计算后日期是周六或周一，则预计日期加2
		if (cTemp.get(Calendar.DAY_OF_WEEK) == 1 || cTemp.get(Calendar.DAY_OF_WEEK) == 7) {
			resultDays += 2;
		}
		// 重新设置计算后日期
		cTemp.set(Calendar.DAY_OF_MONTH,resultDays);
		// 返回 预计日期
		return cTemp.getTime();
	}
}
